Computing Time-Decayed Aggregates in Data Streams

ABSTRACT

Aggregates are calculated from a data stream in which data is sent in a sequence of tuples, in which each tuple comprises an item identifier and a timestamp indicating when the tuple was transmitted. The tuples may arrive out-of-order, that is, the sequence in which the tuples arrive are not necessarily in the sequence of their corresponding timestamps. In calculating aggregates, more recent data may be given more weight by multiplying each tuple by a decay function which is a function of the timestamp associated with the tuple and the current time. The tuples are recorded in a quantile-digest data structure. Aggregates are calculated from the data stored in the quantile-digest data structure.

CROSS-REFERENCE TO RELATED APPLICATION

This application is related to U.S. patent application Ser. No. ______ (Attorney Docket No. 2007-0326A), entitled Computing Time-Decayed Aggregates under a Smooth Decay Function, which is being filed concurrently herewith and which is herein incorporated by reference in its entirety.

BACKGROUND OF THE INVENTION

The present invention relates generally to data processing, and more particularly to computing time-decayed aggregates in data streams.

Statistical analysis of data is a core process for characterizing and controlling systems. In many applications, large volumes of data are generated from multiple data sources as multiple data streams, in which data is updated frequently. In some instances, the updates may be considered to be continuous, or near-continuous. In an industrial application, for example, sensors may provide real-time measurements of process variables such as position, velocity, acceleration, temperature, pressure, humidity, and chemical concentration to a monitoring and control station. In a financial application, multiple order-entry systems may provide near real-time updates of stock prices to a central transaction system. A major application is transport of data across a packet data network. E-mail, instant messaging, file transfers, streaming audio, and streaming video applications may generate large streams of data from multiple data sources, such as personal computers and web servers, across a packet data network. Network operations, administration, maintenance, and provisioning (OAM&P) require accurate characterization of data streams. Network performance and reliability, for example, depend on the traffic capacity of the network infrastructure equipment (such as routers, switches, and servers), on the traffic capacity of the communication links between network infrastructure equipment, and on the network architecture.

In some applications, data may be captured, statically stored in a database, and post-processed. In other applications, real-time, or near real-time, analysis is required. For example, if data traffic to a specific router is becoming excessive, new data traffic may be dynamically re-directed to another router. As another example, if an excessive number of users are accessing a web server, new users may be dynamically re-directed to a mirror server. In applications such as real-time control, the most recent data may have the highest relevancy. Particularly when the data streams are large, selectively filtering the most recent data for analysis reduces the required computational resources, such as processor speed and memory capacity, and computational time.

Commonly, what constitutes the most recent data, for example, is determined by the arrival time of the data at the network element (data receiver) which collects the data. The underlying assumption is that the time order in which the data arrives at the data receiver is the same time order in which the data sources generated the data. In applications such as transport of data across a packet data network, however, this assumption may not hold. For example, if data is generated by multiple sensors and the data is transported across a packet data network to a single monitoring and control station, the data from each sensor may be transported across different routes. The delay across one route may differ from the delay across a different route. In general, the delay across a specific route may be a function of overall data traffic across that route. If the overall data traffic is variable, the delay may also be variable. Consider the example in which data from sensor 1 is generated before data from sensor 2. At a particular instance, the data from sensor 1 may arrive at the monitoring and control station ahead of the data from sensor 2. At a later instance, however, under a different set of network conditions, the data from sensor 2 may arrive ahead of the data from sensor 1.

Even if the data is generated by a single data source, the data may arrive at a data receiver out-of-order. In a packet data network, user data may be segmented into multiple data packets. Depending on the configuration of the packet data network, there may be multiple routes between the data source and the data receiver. As discussed above, the delay across one route may differ from the delay across a second route. Consider the example in which data packet 1 is generated before data packet 2. If the two data packets are transmitted across different routes, and if the delay across the route for data packet 1 sufficiently exceeds the delay across the route for data packet 2, then data packet 2 may arrive before data packet 1.

Statistical properties of data streams are characterized by aggregate statistical values (which are referred to herein simply as aggregates), such as the average number of packets per unit time or the quantile distribution of the number of packets per unit time. Calculating aggregates from large volume unordered data streams may be computationally intensive. Herein, an unordered stream is a data stream in which the age of the data and the time order of the data are not taken into account. If the age (recency) of the data and the time order of the data are of significance, then, in general, calculating aggregates requires additional computational resources and additional computational time. What are needed are method and apparatus for efficiently calculating age-dependent aggregates from large volume data streams in which the data may be received in arbitrary time order.

BRIEF SUMMARY OF THE INVENTION

Data streams arriving at a data receiver may comprise data of different age. In calculating statistical aggregates, more recent data may have more relevance than older data. In an embodiment of the invention, the data stream is comprised of a sequence of tuples, in which each tuple comprises an item identifier and an associated timestamp. The timestamp indicates the time at which the tuple was transmitted by a data source. At the data receiver, a tuple is multiplied by a decay function, which is a function of the current time and the associated timestamp. The decay function gives higher weight to more recent items. The tuples are recorded in a quantile-digest data structure, comprising multiple quantile-digests, which may be compressed to reduce required computer resources, for example, memory and computational time. The quantile-digest data structure accommodates tuples which arrive out-of order, that is, tuples which do not arrive in the same sequence as their timestamps. User-defined aggregate functions may be efficiently calculated with deterministic error bounds.

These and other advantages of the invention will be apparent to those of ordinary skill in the art by reference to the following detailed description and the accompanying drawings.

BRIEF DESCRIPTION OF THE DRAWINGS

FIG. 1 shows a schematic of a data measurement system in a packet data network;

FIG. 2 shows a tree representation of a q-digest data structure;

FIG. 3 shows a schematic of data capture in a sliding-windows model;

FIG. 4 shows a high-level flowchart of an overall process for calculating counts in a sliding-window model;

FIG. 5 shows a flowchart of a process for updating q-digests;

FIG. 6 shows a flowchart of a process for compressing q-digests;

FIG. 7 shows a flowchart of a process for calculating counts;

FIG. 8 shows a flowchart for calculating heavy hitters in an exponential-decay model; and,

FIG. 9 shows a schematic of a computer for computing time-decayed aggregates in out-of-order data streams.

DETAILED DESCRIPTION

FIG. 1 shows a high-level schematic of data measurement system 100. In this example, there are four data sources, DS1 102-DS4 108. Each data source generates an independent data stream. The transmitted data streams corresponding to data sources DS1 102-DS4 108 are transmitted data streams ds1 110-ds4 116, respectively. The transmitted data streams ds1 110-ds4 116 are transported across packet data network 118 to a single data receiver DR0 122. In general, there may be multiple data receivers. In general, a data receiver may receive multiple data streams from multiple packet data networks through multiple ports. The multiple received data streams, however, may be viewed as a single virtual received data stream. In the example shown, the transmitted data streams ds1 110-ds4 116 are combined into a single virtual received data stream ds0 120. The received data stream ds0 120 is processed by data processor DP 124. In FIG. 1, data receiver DR0 122 and data processor DP 124 are shown as separate network elements, such as a router and a workstation, respectively. Data receiver DR0 122 and data processor DP 124, however, may also be integrated into a single network element, such as a server.

Herein, a data stream is represented by an unbounded sequence of tuples e_(i)=<x_(i), w_(i), t_(i)>, where i is a sequential integer index, x_(i) is the identifier of an item, w_(i) is an initial weighting factor, and t_(i) is a timestamp. The index i indicates the arrival order in which a tuple is received at a data receiver. An identifier may be a simple sequence label, such as data₁, data₂, data₃ . . . , or packet₁, packet₂, packet₃ . . . In general, an identifier is a user-defined designation. An item herein refers to user-defined data, which may include values of multiple parameters. For example, in an industrial application, an item may be the value of a single parameter such as temperature, or an item may be the values of a pair of parameters such as temperature and pressure. In a packet data network, an item may be the single value of the source address, or an item may be the values of the (source address, destination address) pair. In another example, an item may include the message body in addition to the source and destination addresses. To simplify the terminology herein, an item with the identifier x₁ is referred to as item x_(i). The initial weighting factor w, modifies the sensitivity of aggregates (see below) to the value of an individual tuple. If the item is a data packet, for example, a weighting factor may be the number of bytes in the data packet. Embodiments may be applied to tuples with arbitrary initial weighting factors w_(i). To simplify the discussion, in the examples below, the weighting factors are all set equal to 1. One skilled in the art may apply other embodiments to applications in which arbitrary initial weighting factors are associated with each tuple. The timestamp t_(i) is the time at which the item was generated by a data source, for example, data source DS1 102 in FIG. 1. The value of the timestamp t, is referenced to the local clock of the data source issuing the timestamp.

As discussed above, data measurement system 100 includes four data sources DS1 102-DS4 108, generating transmitted data streams ds1 110-ds4 116, respectively. Each transmitted data stream may be represented by the tuples e_(n,i)=t_(n,i)>, where n=1-4 is an index representing the number of the data source. That is, data sources DS1 102-DS4 108 correspond to n=1-4, respectively. In examples discussed below, the data analysis is performed on the combined data on received data stream ds0 120. Therefore, the notation herein is simplified by including the source index n as a value in the identifier x_(i). The received data stream ds0 120, then, is represented by the tuples e_(i)=<x_(i), t_(i)>. Note that multiple items may have the same timestamp t_(i). In an advantageous embodiment, the clocks of data sources DS1 102-DS4 108 and data receiver DR0 122 are all synchronized. For example, a synchronization scheme such as network time protocol (NTP) may be used. One skilled in the art may apply other embodiments to data measurement systems in which the clocks are not synchronized. For example, the offsets of the clocks may be determined in advance of the data measurements, and appropriate correction factors may be applied.

Herein, a sequence of tuples is in-order if they arrive at a receiver in the same sequence as their timestamps. For example, consider the tuples in the received data stream ds0 120. As the tuples arrive at the data receiver DR0 122, if the timestamp of a tuple is greater than or equal to the timestamp of the previous tuple, then the tuples are in-order. For example, a sequence of three tuples may arrive in-order with timestamps of 1, 2, and 3 ms, respectively. As discussed above, however, depending on network conditions, tuples may arrive out-of-order. For example, a sequence of three tuples may arrive out-of-order with timestamps of 1, 3, and 2 ms, respectively. The current time is designated herein as time t. The reference for the current time is user-definable. For example, the current time t may be the time at which a tuple in the received data stream ds0 120 is received by data receiver DR0 122 (also referred to as observation time). In another example, the current time t may be the time at which a tuple is processed by data processor DP 124 (also known as query time). In general, there may be a delay between the time at which a tuple is received and the time at which a tuple is processed. As discussed below, processing a data stream of tuples includes calculating aggregates. The age of an item in tuple <x_(i), t_(i)> is referred to herein as the difference between the current time and the time at which the item was generated by the data source, as specified by the timestamp. Let a_(i) represent the age of item in tuple <x_(i), t_(i)>, then a_(i)=t−t_(i). To simplify the terminology, an item in tuple <x_(i), t_(i)> is referred to as item <x_(i), t_(i)>. As discussed above, for some applications, recent data is more significant than earlier data. The degree of significance may be varied by applying an age-dependent weighting factor to an item, such that more recent items, which have a lower age, receive higher weighting factors than older items, which have a higher age.

In an embodiment, time-dependent weighting factors may be generated by decay functions. Different decay functions may be chosen to model different applications. Herein, a function g(a) is a decay function if it satisfies the following two properties:

g(0)=1 and 0≦g(a)≦1 for all a≧0, and

g is monotone decreasing: if a ₁ >a ₂, then g(a ₁)≦g(a ₂)

Examples of decay functions include the following:

Sliding Window.

The decay function is g(a)=1 for a<W and g(a)=0 for all a≧W. Only items whose age is less than a window size W are considered. Older items are dropped completely.

Exponential Decay.

The decay function is g(a)=exp(−λa) where λ is a decay parameter with values λ>0. With this decay function, the time for g to drop by a constant fraction is the same, that is, g(a)/[g(A+a)] for a fixed A is the same for all a.

Polynomial Decay.

The decay function is g(a)=(a+1)^(−α) where α is a decay parameter. It may be used in applications in which exponential decay is too fast.

In many applications, the characteristics of individual tuples are not critical. Aggregate statistical values from a large set of tuples are often used to characterize a data stream. For simplicity, aggregate statistical values are referred to herein as aggregates. Common examples of aggregates include averages and medians. Embodiments may be applied to calculate arbitrary aggregates. In general, an aggregate is a user-defined aggregate function. In the discussions below, examples of aggregates are ranges, quantiles, and heavy hitters. A heavy hitter is an item which appears frequently. The criteria for a heavy hitter is user-definable. As discussed above, calculation of time-decayed aggregates of data streams, in which items may arrive out of order, are important for many applications.

Herein, the following terms are defined for a given input data stream S={<x_(i), t_(i)>}:

Decayed Weight.

The decayed weight of an item at time t is g(a_(i))=g(t−t_(i))

Decayed Count.

The decayed count of the stream at time t is

${D(t)} = {\sum\limits_{i}{g\left( a_{i} \right)}}$

Decayed φ-Quantile.

The decayed φ-quantile of the data stream is the item q satisfying

${\sum\limits_{i,{x_{i} < q}}{g\left( a_{i} \right)}} \leq {\varphi \; D}$ and ${\sum\limits_{i,{x_{i} \leq q}}{g\left( a_{i} \right)}} > {\varphi \; D}$

Decayed φ-Heavy Hitters.

The decayed φ-heavy hitters are the set of items {p} satisfying

${\sum\limits_{i,{x_{i} = p}}{g\left( a_{i} \right)}} \geq {\varphi \; D}$

If there is no time decay [g(a)=1 for all a], the values of the aggregates are independent of the timestamps t and, therefore, independent of arrival order. With time decay, the values of the aggregates do depend on the arrival order. Solving for the exact values of the decayed φ-quantile and of the decayed φ-heavy hitters requires considerable computational resources. In embodiments, the following approximate solutions are used to reduce the required computational resources:

Approximate Solution for Decayed φ-Quantile.

For 0<ε<φ≦1, the ε-approximate decayed φ-quantile is calculated by calculating an item q satisfying

${\left( {\varphi - \varepsilon} \right)D} \leq {\sum\limits_{i,{x_{i} < q}}{g\left( a_{i} \right)}} \leq {\left( {\varphi + \varepsilon} \right)D}$

Approximate Solution for Decayed φ-Heavy Hitters.

For 0<ε<φ≦1 the ε-approximate decayed φ-heavy hitter is calculated by calculating a set of items {p} satisfying

${{\sum\limits_{i,{x_{i} = p}}{g\left( a_{i} \right)}} \geq {\left( {\varphi - \varepsilon} \right)D}},$

and omitting no q such that

${\sum\limits_{i,{x_{i} = q}}{g\left( a_{i} \right)}} \geq {\left( {\varphi + \varepsilon} \right)D}$

Since the value of the decay function depends on the query time (time at which the value of the aggregate is processed or calculated), the values of the approximate decayed aggregate solutions depend on the query time. Herein, a query is a user-defined operation. For example, a query may be the calculation of an aggregate. As another example, a query may be a search for a particular data value in a set of data. The result of a query is referred to herein as the answer to the query.

An embodiment for calculating time-decayed aggregates of data streams in which items arrive in arbitrary order is described herein for a sliding-window decay function. A data structure is constructed to track the decayed count of items in a sliding window as they arrive in arbitrary order. Given a window size w (specified at query time) and a data stream S={<x_(i), t_(i)>}, the function D_(w)(t)=|{i|t−t_(i)<w}| is the decayed count within the window w. To reduce required computational resources, an approximate value of D_(w)(t) with ε relative error is calculated. Each t_(i) is represented as an integer in the range [0 . . . W−1], where W is an upper bound on the window size w. For simplicity, W is represented as a power of 2. No generality is lost since W only has to be an upper bound of w.

An advantageous embodiment uses a quantile-digest (q-digest) data structure. Given a parameter 0<c<1, a q-digest summarizes the frequency distribution f_(i) of a multiset defined by a stream of N items drawn from the domain [0 . . . W−1]. The q-digest may be used to estimate the rank of an item q, which is defined as the number of items dominated by q, that is,

${r(q)} = {\sum\limits_{i < q}{f_{i}.}}$

The data structure maintains an appropriately defined set of dyadic ranges ⊂[0 . . . W−1] and their associated counts. A dyadic range is a range of the form [i2^(j) . . . (i+1)2^(j)−1] for non-negative integers i, j. That is, its length is a multiple of two, and it begins at a multiple of its length. An arbitrary range of integers [a . . . b] may be uniquely partitioned into at most 2 log₂ (b−a) dyadic ranges, with at most 2 dyadic ranges of each length. The q-digest has the following properties:

-   -   Each range, count pair (r, c(r)) has

${{c(r)} \leq \frac{\varepsilon \; N}{\log_{2}W}},$

unless r represents a single item.

-   -   Given a range r, denote its parent range as par(r), and its left         and right child ranges as left(r) and right(r), respectively.         For every (r, c(r)) pair,

${{c\left( {{par}(r)} \right)} + {c\left( {{left}\left( {{par}(r)} \right)} \right)} + {c\left( {{right}\left( {{par}(r)} \right)} \right)}} \geq \frac{\varepsilon \; N}{\log_{2}W}$

-   -   If the range r is present in the data structure, then the range         par(r) is also present in the data structure. In general, a         q-digest data structure may comprise a set of q-digests.

Given query point qε[0 . . . W−1], an estimate of the rank of q, denoted by {circumflex over (r)}(q), may be computed as the sum of the counts of all ranges to the left of q, that is,

${\hat{r}(q)} = {\sum\limits_{{({{r = {\lbrack{l,h}\rbrack}},{c{(r)}}})},{h < q}}{{c(r)}.}}$

The following accuracy guarantee may be shown for the estimate of the rank: {circumflex over (r)}(q)≦r(q)≦{circumflex over (r)}(q)+εN. Similarly, given a query point q, the frequency ƒ_(q) of item q may be estimated as {circumflex over (ƒ)}_(q)={circumflex over (r)}(q+1)−{circumflex over (r)}(q), with the following accuracy guarantee: {circumflex over (ƒ)}_(q)−εN≦ƒ_(q)≦{circumflex over (ƒ)}_(q)+εN. The q-digest may be maintained in space

${O\left( \frac{\log \; W}{\varepsilon} \right)}.$

For simplicity, herein, log refers to log₂. Updates to a q-digest may be performed in time O(log log W), by binary searching the O(log W) dyadic ranges containing the new item to find the appropriate place to record its count. Queries take

${O\left( \frac{\log \; W}{\varepsilon} \right)}.$

The q-digest does not require that all items have unit weight, but can be modified to accept updates with arbitrary (that is, fractional) non-negative weights. Also, multiplying all counts in the data structure by a constant γ gives an accurate summary of the input scaled by γ. The properties of the data structure still hold after these transformations.

As an example, FIG. 2 shows a schematic of q-digest 200, which is represented as a binary tree with nodes 202-230. In this example, W=8, and the full set of possible measurement values are the set of 8 integers [0, . . . , 7]. The value of ε is ½. A complete set of data would report the counts for each integer value. Defined approximations of aggregates may be calculated from the q-digest. Each node 202-230 is labeled with the (range=r, count=c(r)) pair inside the rectangle. The leaf nodes 216-230 represent the full set of integer outcomes [0, . . . , 7]. Therefore, for leaf nodes, the range is a single integer. For the higher-order nodes, 202-214, the range spans more than one integer and is denoted by the pair [min value of range, max value of range]. For nodes 208-214, the ranges are, respectively, [0,1], [2,3], [4,5], and [6,7]. For nodes 204 and 206, the ranges are, respectively, [0,3] and [4,7]. The range for the root node 202 is [0,7]. The q-digest records the count in the nodes with a non-zero count. In FIG. 2, the solid rectangles represent nodes with a non-zero count, and the dashed rectangles represent nodes with a zero count. The q-digest therefore records the (range=r, count=c(r)) pair for nodes 220, 222, 226, 210, 212, 204, 206, and 202. Here, the total count in the q-digest 200 is N=42. Therefore,

$\left( \frac{\varepsilon \; N}{\log \; W} \right) = 7.$

In an embodiment, the sliding-window count may be calculated with a data structure including multiple instances of a q-digest data structure. Let the “right rank” of a timestamp τ, denoted by rr(τ), be defined as the number of input items whose timestamps are greater than τ. Given a window size w≦W at query time, an estimate of rr(t−w) with relative error ε may be calculated. An advantageous data structure may be used to approximate the sliding-window count D_(w)(t) with relative error no more than ε using space

${O\left( {\frac{\log \; W}{\varepsilon}{\log \left( \frac{\varepsilon \; N}{\log \; W} \right)}} \right)}.$

The time taken to update the data structure upon the arrival of a new item is

${O\left( {{\log \left( \frac{\varepsilon \; N}{\log \; W} \right)}\log \; \log \; W} \right)},$

and a query for the count may be answered in time

${O\left( {{\log \; {\log \left( {\varepsilon \; N} \right)}} + \frac{\log \; W}{\varepsilon}} \right)}.$

FIG. 3 shows a high-level schematic of a q-digest data structure for calculating a sliding-window count. Here, the q-digest data structure is represented by the sequence of q-digests Q₁ 338-Q₃ 342. These are discussed in further detail below. The horizontal axis 302-A and vertical axis 302-B both represent time. Horizontal axis 302-A represents the timestamps of items that arrive at a receiver. Vertical axis 302-B represents the times at which a sequence of q-digests are updated. The black dots in item sets 304-310 are generic representations of items and do not necessarily represent one item per black dot. In the figure, the intervals between items are shown as equal. In general, however, the intervals are not necessarily equal. Marker lines 312-320 indicate specific reference times. Marker line 312 indicates the query time t. Marker lines 314-320 indicate timestamps τ₀-τ₃, respectively. The timestamps increase in the order from τ₀ to τ₃. Let

$\alpha = {\frac{3}{\varepsilon}\log \; {W.}}$

Blocks 322-328 represent the α items with the most recent timestamps for the item sets 304-310, respectively. Blocks 330-334 represent the remaining items in the item sets 306-310, respectively.

For item set 304, data structure Q₀ 336 exactly buffers the α items with the most recent timestamps (ties broken arbitrarily). For j>0, Q_(j) is a q-digest that summarizes the most recent 2^(j) α a items of the data stream. Shown in the example are q-digests Q₁ 338-Q₃ 342. The square dots represent nodes, as previously discussed with respect to q-digest 200 in FIG. 2. The tree structures are shown for illustration and do not represent actual data structures. As j increases, the number of items summarized by Q_(j) increases, but the error of estimates provided by Q_(j) also increases. If rr(t−w) is large, using where j is large, is sufficient to estimate rr(t−w), and the relative error is still small. If rr(t−w) is small, then using Q_(j), where j is small, is sufficient to calculate the value, and the relative error is controlled.

High-level flowcharts of a process for calculating a count for a sliding-window model are shown in FIG. 4-FIG. 7. The major operations are summarized in FIG. 4. In step 402, a new arriving item is received as input to the q-digests. In step 404, the q-digests are updated. In step 406, the q-digests are examined to determine whether compression is to be applied. For example, compression may be applied after a user-specified number of arrivals. As another example, compression may be applied when the data structure has grown to a user-defined size. If compression is to be applied, then the process passes to step 408, in which the q-digests are compressed to reduce space. In step 410, the counts, which may be actual or estimates, are calculated from the q-digests. Returning to step 406, if compression is not needed, then the process passes directly to step 410. Details of processes for step 404-step 410 are discussed below.

In prior art (Shrivastava et al., ACM SenSys '04, Nov. 3-5, 2004), the upper bound on the count of a node in the q-digest (herein called the count threshold) increases with the number of items being summarized. In an embodiment, the count threshold of a node within Q_(j) is fixed. The count threshold of Q_(j) is set to 2^(j), and the maximum number of ranges within Q_(j) is bounded by α. As more items are added into Q_(j), the number of ranges within Q_(j) will increase beyond α, and some ranges need to be discarded. The α most recent ranges within Q_(j) are retained, and the rest are discarded. The ranges within Q_(j) are sorted according to increasing order of right endpoints. Ties are broken by putting smaller ranges first. The α right-most items in this sorted order are stored in Q_(j).

FIG. 5 shows a flowchart of a process, in accordance with an embodiment, for updating the q-registers (corresponding to step 404 in FIG. 4). In step 502, a new item with timestamp τ arrives at the receiver node. This item is denoted {τ}. In step 504, the item {τ} is added to the buffer B, which corresponds, for example, to q-digest Q₀ 336 in FIG. 3. This step is represented by the operation B←B∪{τ}. In step 506, the size of B, denoted |B|, is compared with the value

${\alpha = {\frac{3}{\varepsilon}\log \; W}},$

the maximum size of B. If B was not previously full, then in step 506, |B| is not >α, and the process returns to step 502 to await the arrival of the next item. If B was previously full, then in step 506, |B| is >α, and the process passes to step 508. In step 508, a parameter T is set to the minimum value of timestamp τ already present in buffer B. This step is represented by the operation T←min τεB. The item {T} is then deleted from buffer B. Note that {T} is the oldest item in buffer B. That is, once B is full, the oldest item is discarded to make room for a more recent item.

The process then passes to step 510, in which the index j is initialized to 1. The index j is the index of a q-digest in the data structure. The value of j has a maximum value of

$\beta = {{\log \left( \frac{\varepsilon \; N}{\log \; W} \right)}.}$

Step 514 and step 516 are iterated for all q-digests, j=[1 . . . β]. In the first iteration, the process passes from step 512 to step 514, in which the value T is compared with the value τ_(j)=τ₁. As discussed below, the timestamp τ_(j) is the minimum time such that all items with timestamps greater than τ_(j) are properly summarized by Q₁. If T is >τ₁, then in step 516, item {T} is inserted into q-digest Q₁. In the example shown in FIG. 3, this corresponds to Q₁ 338. In step 514, if T is not >τ₁, then the process returns to step 502 to await arrival of the next item. In step 518, the index j is incremented by 1, and the process returns to step 512. Step 514 and step 516 are then iterated for the remaining q-digests Q_(j). In the example shown in FIG. 3, these correspond to Q₂ 340-Q₃ 342. When all the q-digests have been updated, then, in step 512, the process returns to step 502 to await arrival of the next item.

An embodiment of a process for compressing q-digests (corresponding to step 408 in FIG. 4) is described herein. For each q-digest Q_(j), j>0, the timestamp τ_(j) is tracked. This value is the minimum time such that all items with timestamps greater than τ_(j) are properly summarized by Q_(j). That is, τ_(j) is initialized to −1. Anytime a range [l, h] is discarded from Q_(j), τ_(j) is set to max{τ_(j), h}. Also, τ₀ is defined to be the greatest timestamp of an element discarded from Q₀. It is set to −1 if Q₀ has not discarded any item so far. For any τ≧τ_(j), rr(τ) can be estimated using Q_(j) as the sum of the counts in all ranges [l, h] in Q_(j) such that l>τ. If the estimate is denoted by {circumflex over (r)}{circumflex over (r)}_(j) (τ), then,

${{\hat{rr}}_{j}(\tau)} = {\sum\limits_{{({{r = {\lbrack{l,h}\rbrack}},{c{(r)}}})},{l > \tau}}{{c(r)}.}}$

The error in the estimate can only arise through ranges r in Q_(j) that contain τ. That is, r neither falls completely to the left or completely to the right of r in Q_(j). Since there are at most log W ranges that contain τ, the error in estimation is no more than 2^(j) log W. The following relationship then holds if τ≧τ_(j):

rr(τ)≦{circumflex over (r)}{circumflex over (r)}(τ)≦rr(τ)+2^(j) log W.  (E1)

If Q_(j) is full, that is, the number of ranges within Q_(j) is the maximum possible, then

$\begin{matrix} {{{{rr}\left( \tau_{j} \right)} \geq {{\frac{3}{\varepsilon}2^{j}\log \; W} - {2^{j}\log \; {W.{Since}}}}}{{\varepsilon < 1},{then}}{{{rr}\left( \tau_{j} \right)} > {\frac{2^{j + 1}}{\varepsilon}\log \; {W.}}}} & ({E2}) \end{matrix}$

FIG. 6 shows a flowchart of a process, in accordance with an embodiment, for compressing the q-digests (corresponding to step 406 in FIG. 4). In step 602, the index j is initialized to 1. In step 604, the value of/is compared with the maximum value of j, which, as discussed above, is

$\beta = {{\log \left( \frac{\varepsilon \; N}{\log \; W} \right)}.}$

In the first iteration, the process passes to step 606, in which τ₁ is recomputed based on the above description. The process then passes to the sub-process shown in step 608-step 618. Let m, 1≦m≦M be the index of a (range, count) pair in Q_(j), (r_(j,m),c(r_(j,m)))εQ_(j). Step 612 step 616 are then iterated for every (r_(j,m),c(r_(j,m)))εQ_(j). In step 608, the index m is initialized to 1, and the process passes to step 610 in which the index m is compared to the maximum value M. In the first iteration, the process passes to step 612, in which the maximum value of r_(l,m) for (r_(l,m),c(r_(l,m)))εQ₁, denoted max(r_(l,m)), is compared to the value of τ₁. If max(r_(l,m)) is ≦τ₁, the process passes to step 614, in which (r_(l,m),c(r_(l,m))) is deleted from Q_(l). The process then passes to step 616, in which is compressed. In step 612, if max(r_(l,m)) is not ≦τ_(l), then the process passes directly to step 616, in which Q_(l) is compressed. Compression methods are discussed, for example, in (Shrivastava et al., ACM SenSys '04, Nov. 3-5, 2004). In step 618, the index m is incremented by 1, and the process returns to step 610. After step 612-step 616 have been iterated for all M values of (r_(j,m),c(r_(j,m)))εQ_(j), then in step 610 the process passes to step 620, in which the index j is incremented by 1. The process then returns to step 604. After step 606 step 618 have been iterated for all β values of j, then, in step 604, the process is complete, as indicated in step 622.

An embodiment of a process for calculating counts (corresponding to step 408 in FIG. 4) is described herein. Given window size w, the following steps may be used to estimate rr(t−w), that is, to calculate {circumflex over (r)}{circumflex over (r)}_(l)(t−w). Let l≧0 be the smallest integer such that τ_(l)≦t−w. The accuracy guarantee can be shown as follows. If l=0 then the calculation has produced the exact answer. Otherwise, from (E1), 0≦{circumflex over (r)}{circumflex over (r)}_(l)(t−w)−rr(t−w)≦2^(l) log W. Also, since τ_(l−1)≧t−w, and Q_(l−1) must be full (since otherwise τ_(l−1) would be −1), then from (E2), the following holds:

$\begin{matrix} {{{rr}\left( {t - w} \right)} \geq {{rr}\left( \tau_{l - 1} \right)} > {\frac{2^{l}}{\varepsilon}\log \; {W.}}} & ({E3}) \end{matrix}$

Thus, the relative error

$\frac{{{{\hat{rr}}_{l}\left( {t - w} \right)} - {{rr}\left( {t - w} \right)}}}{{rr}\left( {t - w} \right)}$

is bounded by ε.

FIG. 7 shows a flowchart of a process, in accordance with an embodiment, for calculating the count (corresponding to step 408 in FIG. 4). In step 702, the window size w is provided as input. In step 704, if t−w≧τ₀ then, as discussed above, the exact value is calculated. The process passes to step 706, in which |{τεB|τ>t−w}| is calculated. Returning to step 704, if t−w is not ≧τ₀, then the process passes to step 708. The value l is calculated, where l, as discussed above, is the smallest integer such that τ_(l)≦t−w. This step is represented by the operation l=arg min_(l)(τ_(l)≦t−w). Then, in step 710, the estimate {circumflex over (r)}{circumflex over (r)}_(l)(t−w) is calculated.

Summarizing the overall process, in accordance with an embodiment described in the flowchart in FIG. 4, the total space required depends on the total number of q-digests used. Due to the doubling of the count threshold at each level, the largest q-digest needed is Q_(j) for J given by

${{\frac{2^{J}}{\varepsilon}\log \; W} \geq N},$

yielding J=[log(εN)−log log W]. Thus the total space complexity is

${O\left( {\frac{\log \; W}{\varepsilon}{\log \left( \frac{\varepsilon \; N}{\log \; W} \right)}} \right)}.$

Each new arrival requires updating, in the worst case, all J q-digests, each of which takes time O(log log W), giving a worst case time bound of

$O\left( {{\log \left( \frac{\varepsilon \; N}{\log \; W} \right)}\log \; \log \; W} \right)$

for the update. The query time is the time required to find the right Q_(l), which can be done in time O(log J)=O(log log(εN)) (through a binary search on the τ_(j)'s) followed by summing the counts in the appropriate buckets of Q_(l), which can be done in time

$O\left( \frac{\log \; W}{\varepsilon} \right)$

for a total query time complexity of

${O\left( {{\log \; {\log \left( {\varepsilon \; N} \right)}} + \frac{\log \; W}{\varepsilon}} \right)}.$

Each time the compression procedure is performed, it takes time linear in the size of the data structure. Therefore, by running compression after every

$O\left( \frac{\log \; W}{\varepsilon} \right)$

updates, the amortized cost of the compression is

$O\left( {{\log \left( \frac{\varepsilon}{\log \; W} \right)},} \right.$

while the space bounds are as stated above.

For a sliding-window decay function, a process for calculating ranges is discussed herein. As discussed further below, other aggregates, such as quantiles and heavy-hitters, may be calculated from range calculations. Consider a stream of <x_(i),t_(i)> tuples, and let the range be denoted r(w,x)=|{i|x_(i)≦x,t−t_(i)≦w}|. Given (w,x) with 0≦w<W,0≦x<U, an estimate {circumflex over (r)}(w,x) is calculated such that |{circumflex over (r)}(w,x)−(w,x)|≦εD_(w)(t). The required approximation quality depends on D_(w)(t), but not on the number of elements that dominate on the x coordinate. A process, in accordance with an embodiment, for calculating ranges combines the data structure for calculating approximate sliding-window counts with an extra layer of data structures for ranges. The process maintains many q-digests Q₀, Q₁, . . . , each of which orders data along the time dimension. Herein, these q-digests are referred to as time-wise q-digests. Within Q_(j), j>0, the count threshold for each range is set to 2^(j-1). Within each range rεQ_(j), instead of just keeping a count of the number of elements, another q-digest is maintained. These q-digests summarize data along the value-dimension. Herein, these q-digests are referred to as value-wise q-digests.

In one embodiment, the value-wise q-digests within Q_(j) are maintained based on a count threshold of

$\frac{2^{j - 1}}{\log \; U}.$

Each value-wise q-digest for a timestamp range r summarizes the value distribution of all tuples whose timestamps fall within r. Since the timestamp ranges within Q_(j) may overlap, a single item may be present in multiple (up to log W) value-wise q-digests within Q_(j). Similar to the process for calculating counts, Q_(j) also maintains a threshold τ_(j), which is updated as in the process for calculating counts. To estimate r(w, x), a process, in accordance with one embodiment, uses Q_(l), where l is the smallest integer such that τ_(l)≦t−w. Within Q_(l), there are at most log W value-wise q-digests to query based on a dyadic decomposition of the range (t−w,t], and query each of these for the rank of x. Finally, the estimate {circumflex over (r)}(w,x) is the sum of these results. The error of the estimate has two components. Within the time-wise q-digest Q_(l), there is may be incurred an error of up to 2^(l-1) log W, since the number of elements within the timestamp range may be undercounted by up to 2^(l-1) log W. Also, within each value-wise q-digest, there may be incurred an error of up to

${\frac{2^{l - 1}}{\log \; U}\log \; U} = {2^{l - 1}.}$

Since as many as log W value-wise q-digests may be used, the total error due to the value-wise q-digests is bounded by 2^(l-1) log W. Hence, the total error in the estimate is bounded by 2·2^(l-1) log W=2^(l) log W. By choosing

$\alpha = {\frac{3}{\varepsilon}\log \; W}$

ranges within each Q_(j), the result is

$D_{w} \geq {{rr}\left( \tau_{l - 1} \right)} > {\frac{2^{l}\; \log \; W}{\varepsilon}.}$

Thus the error in the estimate of r(w, x) is no more than εD_(w).

The sum of counts of all nodes within all value-wise q-digests within Q_(j) is O(log W rr(τ_(j))), since each item may be included in no more than log W value-wise q-digests within Q_(j). Consider any triple of (parent, left child, right child) ranges within a value-wise q-digest. The total count of these triples must be at least

$\frac{2^{j - 1}}{\log \; U},$

implying that for this many counts, a constant amount space is used. Thus, the total space taken to store Q_(j) is O(log²W log U/ε). As discussed above, there are

$O\left( {\log\left( \frac{\varepsilon \; N}{\log \; W} \right)} \right)$

different time-wise q-digests, leading to a total space complexity of

${O\left( {\frac{1}{\varepsilon}{\log \left( {\varepsilon \; {N/\log}\; W} \right)}\log^{2}\; W\; \log \; U} \right)}.$

Consider the time to update each Q_(j). This requires the insertion of the item into no more than log W value-wise q-digests. Each such insertion takes time O(log log U), and the total time to insert into all Q_(j)'s is

${O\left( {{\log\left( \frac{\varepsilon \; N}{\log \; W} \right)}\log \; {W\left( {\log \; \log \; U} \right)}} \right)} = {{O\left( {{\log \left( {\varepsilon \; N} \right)}\; \log \; {W\left( {\log \; \log \; U} \right)}} \right)}.}$

In another embodiment, ranges are calculated using time-wise q-digests Q_(j), each node of which contains a value-wise q-digest. Here, there are the same number and arrangement of time-wise q-digests. Instead of inserting each update in all value-wise q-digests that summarize time ranges in which it falls, it is inserted in only one, corresponding to the node in the time-wise structure whose count is incremented due to insertion. The pruning condition for the value-wise q-digest is based on εn/2 log U, where n=c(r) is the number of items counted by the time-wise q-digest in the range. Each value-wise q-digest is a q-digest which summarizes the values inserted into it, and so takes space

${O\left( \frac{\log \; U}{\varepsilon} \right)}.$

To calculate values of r(w, q), the value τ_(l) based on w and query Q_(l) is calculated. There may be incurred an error 2^(l-1) log W from uncertainty in Q_(l). All value-wise summaries within Q_(l) which correspond to items arriving within the time window (t−w, t] are merged together, at query time. The value of x is calculated from the resulting q-digest. By the properties of merging q-digests, the error in this calculation is bounded by

$\frac{\varepsilon}{2}{D_{w}.}$

Summing these two components gives the total error bound of εD_(w).

The space required is calculated by taking the number of value-wise q-digests for each

$Q_{j},{O\left( \frac{\log \; W}{\varepsilon} \right)}$

and multiplying by the size of each,

${O\left( \frac{\log \; U}{\varepsilon} \right)},$

over the J=log(εN)−log log W levels. The overall bound is

${O\left( {\frac{1}{\varepsilon^{2}}\log \; U\; \log \; W\; {\log\left( \frac{\varepsilon \; N}{\log \; W} \right)}} \right)}.$

The amortized cost of compression can be made O(1). The overall amortized cost per update is therefore

${O\left( {{\log\left( \frac{\varepsilon \; N}{\log \; W} \right)}\left( {{\log \; \log \; W} + {\log \; \log \; U}} \right)} \right)}.$

Sliding-window range calculations can be approximated in space

$O\left( {\frac{1}{\varepsilon}\log \; U\; \log \; W\; {\log\left( \frac{\varepsilon \; N}{\log \; W} \right)}{\min\left( {{\log \; W},\frac{1}{\varepsilon}} \right)}} \right)$

and time

$O\left( {{\log\left( \frac{\varepsilon \; N}{\log \; W} \right)}\log \; W\; \log \; \log \; U} \right)$

per update. Queries take time linear in the space used.

Calculating quantiles and heavy hitters are discussed herein. Calculating values of heavy hitters and quantiles in a sliding window may be reduced to calculating values of ranges. Approximate answers to range calculations yield good approximations for quantiles and heavy hitters. For a maximum window size W, a data structure for range calculations with accuracy parameter

$\frac{\varepsilon}{2}$

is created. To calculate an approximate φ-quantile, an approximation {circumflex over (D)}_(w of D) _(v), is calculated using the time-wise q-digests. A binary search is then made for the smallest x such that {circumflex over (r)}(w,x)≧φ{circumflex over (D)}_(w). Such an x satisfies the requirements for being an approximate φ-quantile:

${{{{\hat{D}}_{w} - D_{w}}} \leq {\frac{\varepsilon}{2}D_{w}}},{and}$ ${{{\hat{r}\left( {w,x} \right)} - {r\left( {w,x} \right)}}} \leq {\frac{\varepsilon}{2}{D_{w}.}}$

Values of φ-heavy hitters may be calculated by calculating φ′-quantiles, for φ′=ε, 2ε, 3ε . . . 1. All items that repeatedly occur as

$\frac{\varphi}{\varepsilon}$

(or more) consecutive quantiles are reported. If any item has frequency at least (φ+E)D_(w), it will surely be reported. Also, any item which has frequency less than (φ−E)D_(w) will surely not be reported.

Calculating sliding-window quantile and heavy hitters with out-of-order arrivals may be made in the same bounds as calculating sliding-window ranges, as discussed above. This lets window size w<W to be specified at query time. If the window size is fixed to W tuples and only the q-digest for the appropriate τ_(j) is kept, a factor of

$O\left( {\log \left( \frac{\varepsilon \; N}{\log \; W} \right)} \right)$

is saved.

An embodiment for calculating quantiles and heavy hitters for an exponential decay function is discussed herein. Given an arrival of item <x_(i),t_(i)>, a summary of the exponentially decayed data may be generated. Let t′ be the last time the data structure was updated. Every count in the data structure is multiplied by the scalar exp(−λ(t−t′)) so that it reflects the current decayed weights of all items. The q-digest is then updated with the item x₁ with weight exp(−λ(t−t′)). In an advantageous embodiment, the current decayed count D is tracked exactly, and a timestamp t_(r) is kept on each counter c(r) denoting the last time it was updated. Whenever the current value of range r is required, it may be multiplied by exp(−λ(t−t_(r))), and t_(r) is updated to t. This ensures that the asymptotic space and time costs of maintaining an exponentially decayed q-digest remains the same as before.

The process may be verified as follows. Let S(r) denote the subset of input items which the procedure is representing by the range r. When the procedure processes a new update <x_(i),t_(i)> and updates a range r, then set S(r)=S(r)∪i . When the procedure merges a range r′ together into range r by adding the count of (the child range) r′ into the count of r (the parent), then set S(r)=S(r)∪S(r′), and S(r′)=Ø (since r′ has given up its contents). The procedure maintains the property that

${c(r)} = {\sum\limits_{i \in {S{(r)}}}{{\exp \left( {- {\lambda \left( {t - t_{i}} \right)}} \right)}.}}$

very operation which modifies the counts (for example, adding a new item, merging two range counts, or applying the decay functions) maintains this invariant. Every item summarized in S(r) is a member of the range, that is, iεS(r)

x_(i)εr, and at any time each tuple from the input is represented in S(r) is a member of the range r, that is, iεS(r)

x_(i)εr, and, at any time, each tuple i from the input is represented in exactly one range r.

To estimate

${{r_{\lambda}(x)} = {\sum\limits_{i,{x_{i} \leq x}}{\exp \left( {\lambda \left( {t - t_{i}} \right)} \right)}}},$

the following value is computed:

$\hat{r} = {\sum\limits_{{r = {\lbrack{l\mspace{14mu} \ldots \mspace{14mu} h}\rbrack}},{h \leq x}}{{c(r)}.}}$

By the above analysis of c(r), all items that are surely less than x are included, and all items that are surely greater than x are omitted. The uncertainty depends only on the ranges containing x, and the sum of these ranges is at most

${\varepsilon {\sum\limits_{r}{c(r)}}} = {\varepsilon \; {D.}}$

. Values of decayed rank may be calculated deterministically, with bounded approximation error. A φ-quantile with the desired error bounds may be found by binary searching for x whose approximate rank is φD. Under a fixed exponential decay function exp(−λ(t−t_(i))), the following resources are required for specific operations: decayed quantile queries in space

$O\left( {\frac{1}{\varepsilon}\log \; U} \right)$

and time per update O(log log U). Queries take time

${O\left( \frac{\log \; U}{\varepsilon} \right)}.$

In an embodiment, a data structure may be used to calculate heavy hitters under an exponential decay function, since the data structure guarantees an error of at most εD in the count of any single item. The data structure may be scanned to find and estimate all possible heavy hitters in time linear in the size of the data structure. A set of

$O\left( \frac{1}{\varepsilon} \right)$

pairs of item names and counters, with the counters initialized to zero, are tracked. FIG. 8 shows a flowchart for a process, in accordance with an embodiment, for calculating heavy hitters. In step 802, the input values of item identifier x_(i), timestamp t_(i), and decay parameter λ are received. In step 804, the data structure is checked to determine whether it already contains an (item, counter) pair for item {x_(i)}. If there is, the process then passes to step 806, in which the index j is set to index i. This step is represented by the operation j←item⁻¹(x_(i)). The process then passes to step 808, in which the decayed count exp(λt_(i)) is added to the counter for {x_(j)}. This step is represented by the operation count[j]←count[j]+exp(λt_(i)). In step 804, if the data structure does not already contain an (item, counter) pair for item {x_(i)}, then the process passes to step 818, in which the index j is set to the value associated with the item with the lowest count (breaking ties arbitrarily). This step is represented by the operation j←arg min_(k) (count[k]). The process then passes to step 808, in which, as before, the decayed count exp(λt_(i)) is added to the counter for {x_(j)}. The process then passes to step 810, in which the current count is calculated by multiplying count[j] by the time decay factor exp(−λt), where t is the current time. The process then passes to step 812, in which the current count is compared with the threshold value φD, specified for a heavy hitter. If the current count does exceed the threshold value, the process passes to step 814, and the item and its current count are reported. In step 812, if the current count does not exceed the threshold value, the process passes to step 816, and the item and its associated count are not reported. The ε-approximate exponentially decayed heavy hitters are found in space

$O\left( \frac{1}{\varepsilon} \right)$

and updated in time

${O\left( {\log \left( \frac{1}{\varepsilon} \right)} \right)}.$

An embodiment is discussed herein for a process in which an arbitrary decay function is approximated by multiple sliding windows. Consider an arbitrary decay function g(a) and the heavy hitters aggregate. The decayed count of any item x may be represented as the sum

${{{g(0)}{f_{x}(0)}} + {\sum\limits_{j = 1}^{t}{\left( {{g(j)} - {g\left( {j - 1} \right)}} \right){f_{x}(j)}}}},$

where ƒ_(x)(j) denotes the count of item x in the window of size j. The approximate heavy hitters may be calculated by calculating the approximate counts of each item in each window up to t. Because the count of x in window j is approximated with error εD_(j), summing all counts gives the error:

${{\sum\limits_{j = 1}^{t}{g\left( {t - j} \right)}} - {{g\left( {t - j + 1} \right)}\varepsilon \; D_{j}}} = {\varepsilon \; {D.}}$

The speed of the process may be increased by making appropriate use of the contents of the data structure. It is not necessary to enumerate every possible item x. The information on which items are stored in the sliding-window data structure may be used, since items not stored are guaranteed not to be significant under the decay function. In addition, it is not necessary to query all possible time values. Again, the data structure only stores information about a limited number of timestamps, and queries about sliding windows with other timestamps will give the same answers as queries on some timestamp stored in the data structure. Thus, the sum only at timestamps stored in the data structure need to be evaluated, rather than at all possible timestamps. For quantiles, the results are similar. Instead of computing the decayed count of an item, the decayed rank of items is computed, and a binary search is conducted to find the desired quantile. The same space bounds hold. The process is advantageous. It handles item arrivals in completely arbitrary orders. It handles any arbitrary decay function efficiently, and the decay function may be specified at query time, after the input stream has been seen. All these results hold deterministically. Decayed heavy hitter and quantile queries on out-of-order arrivals may be answered within the bounds previously stated for sliding-window range queries. They may be approximated in space

$O\left( {\frac{1}{\varepsilon}\log \; U\; \log \; W\; {\log \left( \frac{\varepsilon \; N}{\log \; W} \right)}{\min \left( {{\log \; W},\frac{1}{\varepsilon}} \right)}} \right)$ and  time $O\left( {{\log \left( \frac{\varepsilon \; N}{\log \; W} \right)}\log \; W\; \log \; \log \; U} \right)$

per update. Queries take time linear in the space used.

One embodiment of a data processor for computing time-decayed aggregates in out-of-order data streams may be implemented using a computer. For example, the steps shown in the flowcharts in FIG. 4-FIG. 8 may be implemented using a computer. As shown in FIG. 9, computer 902 may be any type of well-known computer comprising a central processing unit (CPU) 904, memory 908, data storage 906, and user input/output interface 910. Data storage 906 may comprise a hard drive or non-volatile memory. User input/output interface 910 may comprise a connection to a user input device 916, such as a keyboard or mouse. As is well known, a computer operates under control of computer software which defines the overall operation of the computer and applications. CPU 904 controls the overall operation of the computer and applications by executing computer program instructions which define the overall operation and applications. The computer program instructions may be stored in data storage 906 and loaded into memory 908 when execution of the program instructions is desired. Computer 902 may further comprise a video display interface 912, which may transform signals from CPU 904 to signals which may drive video display 918. Computer 902 may further comprise one or more network interfaces. For example, communications network interface 914 may comprise a connection to an Internet Protocol (IP) communications network 920, which may transport user traffic. For example, communications network interface 914 may connect to data receiver DR0 122 in FIG. 1. Computers are well known in the art and will not be described in detail herein.

The foregoing Detailed Description is to be understood as being in every respect illustrative and exemplary, but not restrictive, and the scope of the invention disclosed herein is not to be determined from the Detailed Description, but rather from the claims as interpreted according to the full breadth permitted by the patent laws. It is to be understood that the embodiments shown and described herein are only illustrative of the principles of the present invention and that various modifications may be implemented by those skilled in the art without departing from the scope and spirit of the invention. Those skilled in the art could implement various other feature combinations without departing from the scope and spirit of the invention. 

1-25. (canceled)
 26. An apparatus comprising: a processor; and a memory to store computer program instructions for calculating a time-decayed aggregate from a data stream comprising a sequence of tuples, each tuple comprising an item identifier and an associated timestamp, the computer program instructions when executed on the processor cause the processor to perform operations comprising: generating a time-dependent weighted sequence of tuples by multiplying each of the sequence of tuples by a time-dependent weighting factor calculated from a decay function, wherein the decay function is a function of the timestamp associated with the tuple and a current time; generating a quantile-digest data structure from the time-dependent weighted sequence of tuples; updating the quantile-digest data structure with the time-dependent weighted sequence of tuples; and, calculating the time-decayed aggregate from the updated quantile-digest data structure.
 27. The apparatus of claim 26, wherein the quantile-digest data structure comprises a set of quantile-digests.
 28. The apparatus of claim 26, wherein the operations further comprise compressing the quantile-digest data structure.
 29. The apparatus of claim 26, wherein the decay function is a sliding-window function.
 30. The apparatus of claim 26, wherein the decay function is an exponential decay function.
 31. The apparatus of claim 26, wherein the decay function is a polynomial decay function.
 32. The apparatus of claim 26, wherein the time-decayed aggregate is a time-decayed user-defined aggregate function.
 33. The apparatus of claim 26, wherein the time-decayed aggregate is a time-decayed count.
 34. The apparatus of claim 26, wherein the time-decayed aggregate is a time-decayed range.
 35. The apparatus of claim 26, wherein the time-decayed aggregate is a time-decayed quantile.
 36. The apparatus of claim 26, wherein the time-decayed aggregate is a time-decayed heavy hitter. 